
import java.util.ArrayList;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author saluzzo
 */
public class Joueur implements InterfaceJoueur {

    int maCouleur;
    int type;
    int[][] matricePlateau;
    int heuristiqueCount;
    int complexite;
    //**************************
    InterfacePlateau plateau;
    //***********************
    
    public Joueur(int couleur, InterfacePlateau plateau, int type) {
        this.heuristiqueCount = 1;
        this.complexite = 2;
        this.maCouleur = couleur;
        this.type = type;
        this.matricePlateau = plateau.getMatricePlateau();
        //**************************
        this.plateau = plateau;
        //***********************
    }

    public Joueur(int couleur, InterfacePlateau plateau, int type, int heuristique, int complexite) {
        this.heuristiqueCount = heuristique;
        this.complexite = complexite;
        this.maCouleur = couleur;
        this.type = type;
        this.matricePlateau = plateau.getMatricePlateau();
        //**************************
        this.plateau = plateau;
        //***********************
    }

    public int getCouleur() {
        return this.maCouleur;
    }

    public int getType() {
        return this.type;
    }

    private int getNbNoir(int[][] matrice) {
        int count = 0;
        for(int i = 0; i< 8; i++) {
            for(int j=0; j< 8; j++) {
                if(matrice[i][j] == -1) count++;
            }
        }
        return count;
    }

    private int getNbBlanc(int[][] matrice) {
        int count = 0;
        for(int i = 0; i< 8; i++) {
            for(int j=0; j< 8; j++) {
                if(matrice[i][j] == 1) count++;
            }
        }
        return count;
    }

    public Coup joue() {
        int[][] plateauEnCours = this.plateau.getMatricePlateau();
        Noeud racine = new Noeud(null, plateauEnCours);
        Arbre toto = null;
        toto = createArbreCoupPossible(plateauEnCours, racine);
        switch(heuristiqueCount) {
            case 1 : //On prends le coup qui nous rapporte le plus
                switch(this.complexite) {
                    case 1:     //Niveau de complexité faible (1)
                        //On determine le coup qui nous permettra d'avoir le plus de pion possible sur le plateau
                        int meilleur = 0;
                        int numerofils = 0;
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            if(this.maCouleur == 1) {       //Si on est blanc
                                if(getNbBlanc(toto.getFils().getRacine().getMatricePrevisionel()) > meilleur) {
                                    meilleur = getNbBlanc(toto.getFils().getRacine().getMatricePrevisionel());
                                    numerofils = i;
                                }
                            } else {                        //Si on est noir
                                if(getNbNoir(toto.getFils().getRacine().getMatricePrevisionel()) > meilleur) {
                                    meilleur = getNbNoir(toto.getFils().getRacine().getMatricePrevisionel());
                                    numerofils = i;
                                }
                            }
                        }

                        //Une fois le coup determiné, on renvoi celui ci
                        return toto.getFils(numerofils).getRacine().getCoupPrevisionnel();

                    case 2:
                        
                        //On créer les coup possible au deuxieme niveau afin d'avoir un arbre a deux niveau
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            toto.getFils(i).addFils(createArbreCoupPossible(toto.getFils(i).getRacine().getMatricePrevisionel(), toto.getFils(i).getRacine()));
                        }

                        //On recupere uniquement le minimum que nous pourrions avoir au niveau 2
                        ArrayList<int[]> listedesmaxadverse = new ArrayList<int[]>();
                        
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            int meilleurcoupadverse = 99999;
                            int indexmeilleurcoupadverse = 0;

                            for(int j = 0; j < toto.getFils(i).getNbFils(); j++) {
                                if(this.maCouleur == 1) {
                                    if(getNbBlanc(toto.getFils(i).getFils(j).getRacine().getMatricePrevisionel()) < meilleurcoupadverse) {
                                        indexmeilleurcoupadverse = j;
                                        meilleurcoupadverse = getNbBlanc(toto.getFils(i).getFils(j).getRacine().getMatricePrevisionel());
                                    }
                                } else {
                                    if(getNbNoir(toto.getFils(i).getFils(j).getRacine().getMatricePrevisionel()) < meilleurcoupadverse) {
                                        indexmeilleurcoupadverse = j;
                                        meilleurcoupadverse = getNbNoir(toto.getFils(i).getFils(j).getRacine().getMatricePrevisionel());
                                    }
                                }
                            }
                            
                            int[] temp = new int[2];
                            temp[0] = indexmeilleurcoupadverse;
                            temp[1] = meilleurcoupadverse;
                            listedesmaxadverse.add(temp);

                        }



                        //Ensuite on recupere le maximum des minimum trouver precedement
                        int meilleurcoupajouer = 0;
                        int indexmeilleurcoupajouer=0;
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            if(listedesmaxadverse.get(i)[1] > meilleurcoupajouer) {
                                indexmeilleurcoupajouer = i;
                                meilleurcoupajouer = listedesmaxadverse.get(i)[1];
                            }
                        }

                        //On retourne le coup determiné
                        return toto.getFils(indexmeilleurcoupajouer).getRacine().getCoupPrevisionnel();

                    case 3:     //Niveau de complexité haut (3)
                        //On créer les coup possible au deuxieme et troisieme niveau afin d'avoir un arbre a trois niveau
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            toto.getFils(i).addFils(createArbreCoupPossible(toto.getFils(i).getRacine().getMatricePrevisionel(), toto.getFils(i).getRacine()));
                            Arbre fils = toto.getFils(i);
                            for(int j = 0; j < fils.getNbFils(); j++) {
                                fils.getFils(j).addFils(createArbreCoupPossible(fils.getFils(j).getRacine().getMatricePrevisionel(), fils.getFils(j).getRacine()));
                            }
                        }

                        ArrayList<int[]> listeCoupNiveau3 = new ArrayList<int[]>();
                        //On determine les coup qui nous rapporte le maximum de pions au niveau 3
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            for(int j = 0; j < toto.getFils(i).getNbFils(); j++) {
                                int meilleurcoupniveau3 = 0;
                                int indexmeilleurcoupniveau3 =0;
                                for(int k = 0; k < toto.getFils(i).getFils(j).getNbFils(); k++) {
                                    if(this.maCouleur == 1) {
                                        if( this.getNbBlanc(toto.getFils(i).getFils(j).getFils(k).getRacine().getMatricePrevisionel()) > meilleurcoupniveau3) {
                                            indexmeilleurcoupniveau3 = i;
                                            meilleurcoupniveau3 = this.getNbBlanc(toto.getFils(i).getFils(j).getFils(k).getRacine().getMatricePrevisionel());
                                        }
                                    } else {
                                        if( this.getNbNoir(toto.getFils(i).getFils(j).getFils(k).getRacine().getMatricePrevisionel()) > meilleurcoupniveau3) {
                                            indexmeilleurcoupniveau3 = i;
                                            meilleurcoupniveau3 = this.getNbBlanc(toto.getFils(i).getFils(j).getFils(k).getRacine().getMatricePrevisionel());
                                        }
                                    }
                                }

                                int[] temp = new int[2];
                                temp[0] = indexmeilleurcoupniveau3;
                                temp[1] = meilleurcoupniveau3;
                                listeCoupNiveau3.add(temp);
                            }
                        }

                        ArrayList<int[]> listeCoupNiveau2 = new ArrayList<int[]>();
                        //On prend le minimum des pions qui nous rapport
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            int indexmeilleurcoupniveau2 = 0;
                            int meilleurcoupniveau2 = Integer.MAX_VALUE;
                            for(int j = 0; j < toto.getFils(i).getNbFils(); j++) {
                                if(listeCoupNiveau3.get(j)[1] < meilleurcoupniveau2 ) {
                                    indexmeilleurcoupniveau2 = j;
                                    meilleurcoupniveau2 = listeCoupNiveau3.get(j)[1];
                                }
                            }

                            int[] temp = new int[2];
                            temp[0] = indexmeilleurcoupniveau2;
                            temp[1] = meilleurcoupniveau2;
                            listeCoupNiveau2.add(temp);
                        }



                        int indexmeilleurcoupniveau1 = 0;
                        int meilleurcoupniveau1 = Integer.MIN_VALUE;
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            if(listeCoupNiveau2.get(i)[1] > meilleurcoupniveau1) {
                                indexmeilleurcoupniveau1 = i;
                                meilleurcoupniveau1 = listeCoupNiveau2.get(i)[1];
                            }
                        }

                        //On retourne le coup determiné
                        return toto.getFils(indexmeilleurcoupniveau1).getRacine().getCoupPrevisionnel();

                }

            case 2: //On prend le coup qui rapporte le moins a l'adversaire

                switch(complexite) {
                    case 1:     //Niveau de complexité faible (1)
                        //On determine le coup qui nous permettra d'avoir le moins de pion possible de l'adversaire sur le plateau
                        int meilleur = 0;
                        int numerofils = 0;
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            if(this.maCouleur == 1) {           //Si on est blanc
                                if(getNbNoir(toto.getFils().getRacine().getMatricePrevisionel()) < meilleur) {
                                    meilleur = getNbNoir(toto.getFils().getRacine().getMatricePrevisionel());
                                    numerofils = i;
                                }
                            } else {                            //Si on est noir
                                if(getNbBlanc(toto.getFils().getRacine().getMatricePrevisionel()) < meilleur) {
                                    meilleur = getNbBlanc(toto.getFils().getRacine().getMatricePrevisionel());
                                    numerofils = i;
                                }
                            }
                        }
                        return toto.getFils(numerofils).getRacine().getCoupPrevisionnel();

                    case 2:     //Niveau de complexité moyen (2)
                        //On créer les coup possible au deuxieme niveau afin d'avoir un arbre a deux niveau
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            toto.getFils(i).addFils(createArbreCoupPossible(toto.getFils(i).getRacine().getMatricePrevisionel(), toto.getFils(i).getRacine()));
                        }

                        //On recupere uniquement le maximum que peut faire l'adversaire
                        ArrayList<int[]> listedesmaxadverse = new ArrayList<int[]>();

                        for(int i = 0; i < toto.getNbFils(); i++) {
                            int meilleurcoupadverse = 99999;
                            int indexmeilleurcoupadverse = 0;

                            for(int j = 0; j < toto.getFils(i).getNbFils(); j++) {
                                if(this.maCouleur == 1) {
                                    if(getNbNoir(toto.getFils(i).getFils(j).getRacine().getMatricePrevisionel()) > meilleurcoupadverse) {
                                        indexmeilleurcoupadverse = j;
                                        meilleurcoupadverse = getNbNoir(toto.getFils(i).getFils(j).getRacine().getMatricePrevisionel());
                                    }
                                } else {
                                    if(getNbBlanc(toto.getFils(i).getFils(j).getRacine().getMatricePrevisionel()) > meilleurcoupadverse) {
                                        indexmeilleurcoupadverse = j;
                                        meilleurcoupadverse = getNbBlanc(toto.getFils(i).getFils(j).getRacine().getMatricePrevisionel());
                                    }
                                }
                            }

                            int[] temp = new int[2];
                            temp[0] = indexmeilleurcoupadverse;
                            temp[1] = meilleurcoupadverse;
                            listedesmaxadverse.add(temp);

                        }

                        //Ensuite on recupere le minimum de ces maximum
                        int meilleurcoupajouer = 0;
                        int indexmeilleurcoupajouer=0;
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            if(listedesmaxadverse.get(i)[1] < meilleurcoupajouer) {
                                indexmeilleurcoupajouer = i;
                                meilleurcoupajouer = listedesmaxadverse.get(i)[1];
                            }
                        }

                        return toto.getFils(indexmeilleurcoupajouer).getRacine().getCoupPrevisionnel();

                    case 3:     //Niveau de complexité haut (3)
                        //On créer les coup possible au deuxieme et troisieme niveau afin d'avoir un arbre a trois niveau
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            toto.getFils(i).addFils(createArbreCoupPossible(toto.getFils(i).getRacine().getMatricePrevisionel(), toto.getFils(i).getRacine()));
                            Arbre fils = toto.getFils(i);
                            for(int j = 0; j < fils.getNbFils(); j++) {
                                fils.getFils(j).addFils(createArbreCoupPossible(fils.getFils(j).getRacine().getMatricePrevisionel(), fils.getFils(j).getRacine()));
                            }
                        }

                        ArrayList<int[]> listeCoupNiveau3 = new ArrayList<int[]>();
                        //On determine les coup qui rapporte le minimum de pions pour l'adversaire au niveau 3
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            for(int j = 0; j < toto.getFils(i).getNbFils(); j++) {
                                int meilleurcoupniveau3 = Integer.MAX_VALUE;
                                int indexmeilleurcoupniveau3 =0;
                                for(int k = 0; k < toto.getFils(i).getFils(j).getNbFils(); k++) {
                                    if(this.maCouleur == 1) {
                                        if( this.getNbNoir(toto.getFils(i).getFils(j).getFils(k).getRacine().getMatricePrevisionel()) < meilleurcoupniveau3) {
                                            indexmeilleurcoupniveau3 = i;
                                            meilleurcoupniveau3 = this.getNbNoir(toto.getFils(i).getFils(j).getFils(k).getRacine().getMatricePrevisionel());
                                        }
                                    } else {
                                        if( this.getNbBlanc(toto.getFils(i).getFils(j).getFils(k).getRacine().getMatricePrevisionel()) < meilleurcoupniveau3) {
                                            indexmeilleurcoupniveau3 = i;
                                            meilleurcoupniveau3 = this.getNbBlanc(toto.getFils(i).getFils(j).getFils(k).getRacine().getMatricePrevisionel());
                                        }
                                    }
                                }

                                int[] temp = new int[2];
                                temp[0] = indexmeilleurcoupniveau3;
                                temp[1] = meilleurcoupniveau3;
                                listeCoupNiveau3.add(temp);
                            }
                        }

                        ArrayList<int[]> listeCoupNiveau2 = new ArrayList<int[]>();
                        //On prend le maximum des des minimum
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            int indexmeilleurcoupniveau2 = 0;
                            int meilleurcoupniveau2 = Integer.MIN_VALUE;
                            for(int j = 0; j < toto.getFils(i).getNbFils(); j++) {
                                if(listeCoupNiveau3.get(j)[1] > meilleurcoupniveau2 ) {
                                    indexmeilleurcoupniveau2 = j;
                                    meilleurcoupniveau2 = listeCoupNiveau3.get(j)[1];
                                }
                            }

                            int[] temp = new int[2];
                            temp[0] = indexmeilleurcoupniveau2;
                            temp[1] = meilleurcoupniveau2;
                            listeCoupNiveau2.add(temp);
                        }



                        int indexmeilleurcoupniveau1 = 0;
                        int meilleurcoupniveau1 = Integer.MAX_VALUE;
                        for(int i = 0; i < toto.getNbFils(); i++) {
                            if(listeCoupNiveau2.get(i)[1] < meilleurcoupniveau1) {
                                indexmeilleurcoupniveau1 = i;
                                meilleurcoupniveau1 = listeCoupNiveau2.get(i)[1];
                            }
                        }

                        //On retourne le coup determiné
                        return toto.getFils(indexmeilleurcoupniveau1).getRacine().getCoupPrevisionnel();
                }
        }
        
        return null;
    }

    public Arbre createArbreCoupPossible(int[][] plateauEnCours, Noeud racine) {
        int[][] plateauBegin = plateauEnCours;
        ArrayList<Coup> listePions = new ArrayList<Coup>();
        Arbre arbre = new Arbre(racine);
        for(int x=0;x<Constantes.DIM; x++) {
            for(int y=0; y<Constantes.DIM;y++) {
                if(plateauEnCours[x][y] == this.maCouleur){
                    listePions.add(new Coup(x, y));
                }
            }
        }
        
        for(int index=0; index < listePions.size(); index++) {
            Coup test = null;
            
            boolean niv1=false;
            boolean niv2=false;
            boolean niv3=false;
            boolean niv4=false;
            boolean niv5=false;
            boolean niv6=false;
            boolean niv7=false;
            boolean niv8=false;
            
            do {
                if ((test = firstIterCoup(listePions.get(index), plateauEnCours, false, true, false)) == null || niv1==true) {
                    if ((test = firstIterCoup(listePions.get(index), plateauEnCours, false, false, false)) == null || niv2==true) {
                        if ((test = firstIterCoup(listePions.get(index), plateauEnCours, true, true, false)) == null || niv3==true) {
                            if ((test = firstIterCoup(listePions.get(index), plateauEnCours, true, false, false)) == null || niv4==true) {

                                //Cas de diagonale
                                if ((test = firstIterCoup(listePions.get(index), plateauEnCours, false, true, true)) == null || niv5==true) {
                                    if ((test = firstIterCoup(listePions.get(index), plateauEnCours, false, false, true)) == null || niv6==true) {
                                        if ((test = firstIterCoup(listePions.get(index), plateauEnCours, true, true, true)) == null || niv7==true) {
                                            if ((test = firstIterCoup(listePions.get(index), plateauEnCours, true, false, true)) == null || niv8==true) {
                                                if(niv8==true) {
                                                    test = null;
                                                }
                                            } else niv8=true;
                                        } else niv7=true;
                                    } else niv6=true;
                                } else niv5=true;
                                //Fin de cas de diagonale

                            } else niv4=true;
                        } else niv3=true;
                    } else niv2=true;
                } else niv1=true;
                
                if(test != null) {
                    int[][] matricePrevisionnel = new int[8][8];
                    for(int i = 0; i< 8; i++) {
                        for(int j=0; j< 8; j++) {
                            matricePrevisionnel[i][j] = plateauBegin[i][j];
                        }
                    }
                    matricePrevisionnel[test.getLigne()][test.getColonne()] = this.maCouleur;
                    for (int i = 1; i <= 8; i++ ) {
                        matricePrevisionnel = simulCoup(i, matricePrevisionnel, test);
                    }
                    arbre.addFils(new Arbre(new Noeud(test, matricePrevisionnel)));
                    matricePrevisionnel = null;
                }

            } while( test != null);
        }
        return arbre;
    }
    public Coup firstIterCoup(Coup courant, int[][] plateauEnCours, boolean x, boolean incrementation, boolean diag) {
        int xCourant = courant.getColonne();
        int yCourant = courant.getLigne();

        if(diag) {
            if(x) {
                if(incrementation) {
                    xCourant++;
                    yCourant++;
                } else {
                    xCourant--;
                    yCourant--;
                }
            } else {
                if(incrementation) {
                    xCourant++;
                    yCourant--;
                } else {
                    xCourant--;
                    yCourant++;
                }
            }
        }
        else {
            if(x) {
                if(incrementation) {
                    xCourant++;
                } else {
                    xCourant--;
                }
            }
            else {
                if(incrementation) {
                    yCourant++;
                } else {
                    yCourant--;
                }
            }
        }
        
        
        if(xCourant >= Constantes.DIM || xCourant < 0) return null;
        if(yCourant >= Constantes.DIM || yCourant < 0) return null;

        if (plateauEnCours[yCourant][xCourant] == Constantes.VIDE) {
            return null;
        } else if (plateauEnCours[yCourant][xCourant] == this.maCouleur) {
            return null;
        } else if (plateauEnCours[yCourant][xCourant] == -this.maCouleur) {
            return nextIterCoup(new Coup(yCourant, xCourant), plateauEnCours, x, incrementation, diag);
        }
        return null;
    }

    public Coup nextIterCoup(Coup courant, int[][] plateauEnCours, boolean x, boolean incrementation, boolean diag) {
        int xCourant = courant.getColonne();
        int yCourant = courant.getLigne();

        if(diag) {
            if(x) {
                if(incrementation) {
                    xCourant++;
                    yCourant++;
                } else {
                    xCourant--;
                    yCourant--;
                }
            } else {
                if(incrementation) {
                    xCourant++;
                    yCourant--;
                } else {
                    xCourant--;
                    yCourant++;
                }
            }
        }
        else {
            if(x) {
                if(incrementation) {
                    xCourant++;
                } else {
                    xCourant--;
                }
            }
            else {
                if(incrementation) {
                    yCourant++;
                } else {
                    yCourant--;
                }
            }
        }

        if(xCourant >= Constantes.DIM || xCourant < 0) return null;
        if(yCourant >= Constantes.DIM || yCourant < 0) return null;
        
        if (plateauEnCours[yCourant][xCourant] == Constantes.VIDE) {
            return new Coup(yCourant, xCourant);
        } else if (plateauEnCours[yCourant][xCourant] == this.maCouleur) {
            return null;
        } else if (plateauEnCours[yCourant][xCourant] == -this.maCouleur) {
            return nextIterCoup(new Coup(yCourant, xCourant), plateauEnCours, x, incrementation, diag);
        }
        return null;
    }

    private int[][] simulCoup(int sens, int[][] matrice, Coup coup) {
        int yMax = matrice.length-1;
        int xMax = matrice[0].length-1;
        int x = coup.getColonne();
        int y = coup.getLigne();
        ArrayList<Coup> listeCoup = new ArrayList<Coup>();
        boolean findMe = true;
        switch(sens) {
            case 1: //Est
                if(x < xMax) x++;
                while(x < xMax && matrice[y][x] == -this.maCouleur && findMe) {
                    
                    listeCoup.add(new Coup(y, x));
                    if(matrice[y][x] == this.maCouleur) {
                        findMe = false;
                    }
                    x++;
                }
                if(matrice[y][x] == this.maCouleur) {
                    findMe = false;
                }
                if(!findMe) {
                    //joue les coups
                    for(int i = 0; i< listeCoup.size(); i++) {
                        matrice[listeCoup.get(i).getLigne()][listeCoup.get(i).getColonne()] = this.maCouleur;
                    }
                }
                break;
            case 2: //Sud Est
                if( x < xMax) x++;
                if( y < yMax) y++;
                while((x < xMax || y < yMax) && matrice[y][x] == -this.maCouleur && findMe) {
                    
                    listeCoup.add(new Coup(y, x));
                    if(matrice[y][x] == this.maCouleur) {
                        findMe = false;
                    }
                    if( x < xMax) x++;
                    if( y < yMax) y++;
                }
                if(matrice[y][x] == this.maCouleur) {
                    findMe = false;
                }
                if(!findMe) {
                    //joue les coups
                    for(int i = 0; i< listeCoup.size(); i++) {
                        matrice[listeCoup.get(i).getLigne()][listeCoup.get(i).getColonne()] = this.maCouleur;
                    }
                }
                break;
            case 3: //Sud
                if( y < yMax) y++;
                while(y < yMax && matrice[y][x] == -this.maCouleur && findMe) {
                    
                    listeCoup.add(new Coup(y, x));
                    if(matrice[y][x] == this.maCouleur) {
                        findMe = false;
                    }
                    y++;
                }
                if(matrice[y][x] == this.maCouleur) {
                    findMe = false;
                }
                if(!findMe) {
                    //joue les coups
                    for(int i = 0; i< listeCoup.size(); i++) {
                        matrice[listeCoup.get(i).getLigne()][listeCoup.get(i).getColonne()] = this.maCouleur;
                    }
                }
                break;
            case 4: //Sud ouest
                if( x > 0) x--;
                if( y < yMax) y++;
                while((x > 0 || y < yMax) && matrice[y][x] == -this.maCouleur && findMe) {
                    listeCoup.add(new Coup(y, x));
                    if(matrice[y][x] == this.maCouleur) {
                        findMe = false;
                    }
                    if( x > 0) x--;
                    if( y < yMax) y++;
                }
                if(matrice[y][x] == this.maCouleur) {
                    findMe = false;
                }
                if(!findMe) {
                    //joue les coups
                    for(int i = 0; i < listeCoup.size(); i++) {
                        matrice[listeCoup.get(i).getLigne()][listeCoup.get(i).getColonne()] = this.maCouleur;
                    }
                }
                break;
            case 5: //Ouest
                if( x > 0) x--;
                while(x > 0 && matrice[y][x] == -this.maCouleur && findMe) {
                    
                    listeCoup.add(new Coup(y, x));
                    if(matrice[y][x] == this.maCouleur) {
                        findMe = false;
                    }
                    x--;
                }
                if(matrice[y][x] == this.maCouleur) {
                    findMe = false;
                }
                if(!findMe) {
                    //joue les coups
                    for(int i = 0; i< listeCoup.size(); i++) {
                        matrice[listeCoup.get(i).getLigne()][listeCoup.get(i).getColonne()] = this.maCouleur;
                    }
                }
                break;
            case 6: //Nord ouest
                if( x > 0) x--;
                if( y > 0) y--;
                while((x > 0 || y > 0 )&& matrice[y][x] == -this.maCouleur && findMe) {
                    listeCoup.add(new Coup(y, x));
                    if(matrice[y][x] == this.maCouleur) {
                        findMe = false;
                    }
                    if( x > 0) x--;
                    if( y > 0) y--;
                }
                if(matrice[y][x] == this.maCouleur) {
                    findMe = false;
                }
                if(!findMe) {
                    //joue les coups
                    for(int i = 0; i < listeCoup.size(); i++) {
                        matrice[listeCoup.get(i).getLigne()][listeCoup.get(i).getColonne()] = this.maCouleur;
                    }
                }
                break;
            case 7: // Nord
                if(y>0) y--;
                while(y > 0 && matrice[y][x] == -this.maCouleur && findMe) {
                    
                    listeCoup.add(new Coup(y, x));
                    if(matrice[y][x] == this.maCouleur) {
                        findMe = false;
                    }
                    y--;
                }
                if(matrice[y][x] == this.maCouleur) {
                    findMe = false;
                }
                if(!findMe) {
                    //joue les coups
                    for(int i = 0; i< listeCoup.size(); i++) {
                        matrice[listeCoup.get(i).getLigne()][listeCoup.get(i).getColonne()] = this.maCouleur;
                    }
                }
                break;
            case 8: //Nord Est
                if( x < xMax) x++;
                if( y > 0) y--;
                while((x < xMax || y > 0) && matrice[y][x] == -this.maCouleur && findMe) {
                    listeCoup.add(new Coup(y, x));
                    if(matrice[y][x] == this.maCouleur) {
                        findMe = false;
                    }
                    if( x < xMax) x++;
                    if( y > 0) y--;
                }
                if(matrice[y][x] == this.maCouleur) {
                    findMe = false;
                }
                if(!findMe) {
                    //joue les coups
                    for(int i = 0; i< listeCoup.size(); i++) {
                        matrice[listeCoup.get(i).getLigne()][listeCoup.get(i).getColonne()] = this.maCouleur;
                    }
                }
                break;
        }
        return matrice;
    }

}
